home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / Memory.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  15.0 KB  |  584 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Memory.p
  3.  
  4.      Contains:    Memory Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Memory;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __MEMORY__}
  30. {$SETC __MEMORY__ := 1}
  31.  
  32. {$I+}
  33. {$SETC MemoryIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$PUSH}
  47. {$ALIGN MAC68K}
  48. {$LibExport+}
  49.  
  50. CONST
  51.     maxSize                        = $800000;                        {Max data block size is 8 megabytes}
  52.     defaultPhysicalEntryCount    = 8;
  53. { values returned from the GetPageState function }
  54.     kPageInMemory                = 0;
  55.     kPageOnDisk                    = 1;
  56.     kNotPaged                    = 2;
  57.  
  58. { masks for Zone->heapType field }
  59.     k32BitHeap                    = 1;                            { valid in all Memory Managers }
  60.     kNewStyleHeap                = 2;                            { true if new Heap Manager is present }
  61.     kNewDebugHeap                = 4;                            { true if new Heap Manager is running in debug mode on this heap }
  62.  
  63. { size of a block in bytes }
  64.     
  65. TYPE
  66.     Size = LONGINT;
  67.  
  68.     GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  69.     PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  70.     {
  71.         UserFnProcPtr uses register based parameters on the 68k and cannot
  72.         be written in or called from a high-level language without the help of
  73.         mixed mode or assembly glue.
  74.  
  75.         In:
  76.          => *parameter      A0.L
  77.     }
  78.     UserFnProcPtr = Register68kProcPtr;  { register PROCEDURE UserFn(parameter: UNIV Ptr); }
  79.     GrowZoneUPP = UniversalProcPtr;
  80.     PurgeUPP = UniversalProcPtr;
  81.     UserFnUPP = UniversalProcPtr;
  82.  
  83.     THz = ^Zone;
  84.  
  85.     Zone = RECORD
  86.         bkLim:                    Ptr;
  87.         purgePtr:                Ptr;
  88.         hFstFree:                Ptr;
  89.         zcbFree:                LONGINT;
  90.         gzProc:                    GrowZoneUPP;
  91.         moreMast:                INTEGER;
  92.         flags:                    INTEGER;
  93.         cntRel:                    INTEGER;
  94.         maxRel:                    INTEGER;
  95.         cntNRel:                INTEGER;
  96.         heapType:                SInt8; (* Byte *)
  97.         unused:                    SInt8; (* Byte *)
  98.         cntEmpty:                INTEGER;
  99.         cntHandles:                INTEGER;
  100.         minCBFree:                LONGINT;
  101.         purgeProc:                PurgeUPP;
  102.         sparePtr:                Ptr;
  103.         allocPtr:                Ptr;
  104.         heapData:                INTEGER;
  105.     END;
  106.  
  107.     MemoryBlock = RECORD
  108.         address:                Ptr;
  109.         count:                    LONGINT;
  110.     END;
  111.  
  112.     LogicalToPhysicalTable = RECORD
  113.         logical:                MemoryBlock;
  114.         physical:                ARRAY [0..defaultPhysicalEntryCount-1] OF MemoryBlock;
  115.     END;
  116.  
  117.     PageState = INTEGER;
  118.  
  119.     StatusRegisterContents = INTEGER;
  120.  
  121. CONST
  122.     uppGrowZoneProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  123.     uppPurgeProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  124.     uppUserFnProcInfo = $00009802; { Register PROCEDURE (4 bytes in A0); }
  125.  
  126. FUNCTION NewGrowZoneProc(userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  127.     {$IFC NOT GENERATINGCFM }
  128.     INLINE $2E9F;
  129.     {$ENDC}
  130.  
  131. FUNCTION NewPurgeProc(userRoutine: PurgeProcPtr): PurgeUPP;
  132.     {$IFC NOT GENERATINGCFM }
  133.     INLINE $2E9F;
  134.     {$ENDC}
  135.  
  136. FUNCTION NewUserFnProc(userRoutine: UserFnProcPtr): UserFnUPP;
  137.     {$IFC NOT GENERATINGCFM }
  138.     INLINE $2E9F;
  139.     {$ENDC}
  140.  
  141. FUNCTION CallGrowZoneProc(cbNeeded: Size; userRoutine: GrowZoneUPP): LONGINT;
  142.     {$IFC NOT GENERATINGCFM}
  143.     INLINE $205F, $4E90;
  144.     {$ENDC}
  145.  
  146. PROCEDURE CallPurgeProc(blockToPurge: Handle; userRoutine: PurgeUPP);
  147.     {$IFC NOT GENERATINGCFM}
  148.     INLINE $205F, $4E90;
  149.     {$ENDC}
  150.  
  151. PROCEDURE CallUserFnProc(parameter: UNIV Ptr; userRoutine: UserFnUPP);
  152.     {$IFC NOT GENERATINGCFM}
  153.     {To be implemented:  Glue to move parameters into registers.}
  154.     {$ENDC}
  155. FUNCTION GetApplLimit : Ptr;
  156.     {$IFC NOT CFMSYSTEMCALLS}
  157.     INLINE $2EB8, $0130;            { MOVE.l $0130,(SP) }
  158.     {$ENDC}
  159.  
  160. FUNCTION SystemZone : THz;
  161.     {$IFC NOT CFMSYSTEMCALLS}
  162.     INLINE $2EB8, $02A6;            { MOVE.l $02A6,(SP) }
  163.     {$ENDC}
  164.  
  165. FUNCTION ApplicationZone : THz;
  166.     {$IFC NOT CFMSYSTEMCALLS}
  167.     INLINE $2EB8, $02AA;            { MOVE.l $02AA,(SP) }
  168.     {$ENDC}
  169.  
  170. FUNCTION GZSaveHnd : Handle;
  171.     {$IFC NOT CFMSYSTEMCALLS}
  172.     INLINE $2EB8, $0328;            { MOVE.l $0328,(SP) }
  173.     {$ENDC}
  174.  
  175. FUNCTION TopMem : Ptr;
  176.     {$IFC NOT CFMSYSTEMCALLS}
  177.     INLINE $2EB8, $0108;            { MOVE.l $0108,(SP) }
  178.     {$ENDC}
  179.  
  180. FUNCTION MemError : OSErr;
  181.     {$IFC NOT CFMSYSTEMCALLS}
  182.     INLINE $3EB8, $0220;            { MOVE.w $0220,(SP) }
  183.     {$ENDC}
  184.  
  185. FUNCTION GetZone: THz;
  186.     {$IFC NOT GENERATINGCFM}
  187.     INLINE $A11A, $2E88;
  188.     {$ENDC}
  189. FUNCTION NewHandle(byteCount: Size): Handle;
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $201F, $A122, $2E88;
  192.     {$ENDC}
  193. FUNCTION NewHandleSys(byteCount: Size): Handle;
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $201F, $A522, $2E88;
  196.     {$ENDC}
  197. FUNCTION NewHandleClear(byteCount: Size): Handle;
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $201F, $A322, $2E88;
  200.     {$ENDC}
  201. FUNCTION NewHandleSysClear(byteCount: Size): Handle;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $201F, $A722, $2E88;
  204.     {$ENDC}
  205. FUNCTION HandleZone(h: Handle): THz;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $205F, $A126, $2E88;
  208.     {$ENDC}
  209. FUNCTION RecoverHandle(p: Ptr): Handle;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $205F, $A128, $2E88;
  212.     {$ENDC}
  213. FUNCTION RecoverHandleSys(p: Ptr): Handle;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $205F, $A528, $2E88;
  216.     {$ENDC}
  217. FUNCTION NewPtr(byteCount: Size): Ptr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $201F, $A11E, $2E88;
  220.     {$ENDC}
  221. FUNCTION NewPtrSys(byteCount: Size): Ptr;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $201F, $A51E, $2E88;
  224.     {$ENDC}
  225. FUNCTION NewPtrClear(byteCount: Size): Ptr;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $201F, $A31E, $2E88;
  228.     {$ENDC}
  229. FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $201F, $A71E, $2E88;
  232.     {$ENDC}
  233. FUNCTION PtrZone(p: Ptr): THz;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $205F, $A148, $2E88;
  236.     {$ENDC}
  237. FUNCTION MaxBlock: LONGINT;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $A061, $2E80;
  240.     {$ENDC}
  241. FUNCTION MaxBlockSys: LONGINT;
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $A461, $2E80;
  244.     {$ENDC}
  245. FUNCTION StackSpace: LONGINT;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $A065, $2E80;
  248.     {$ENDC}
  249. FUNCTION NewEmptyHandle: Handle;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $A166, $2E88;
  252.     {$ENDC}
  253. FUNCTION NewEmptyHandleSys: Handle;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $A566, $2E88;
  256.     {$ENDC}
  257. PROCEDURE HLock(h: Handle);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $205F, $A029;
  260.     {$ENDC}
  261. PROCEDURE HUnlock(h: Handle);
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $205F, $A02A;
  264.     {$ENDC}
  265. PROCEDURE HPurge(h: Handle);
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $205F, $A049;
  268.     {$ENDC}
  269. PROCEDURE HNoPurge(h: Handle);
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $205F, $A04A;
  272.     {$ENDC}
  273. PROCEDURE HLockHi(h: Handle);
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $205F, $A064, $A029;
  276.     {$ENDC}
  277. FUNCTION TempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $3F3C, $001D, $A88F;
  280.     {$ENDC}
  281. FUNCTION TempMaxMem(VAR grow: Size): Size;
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $3F3C, $0015, $A88F;
  284.     {$ENDC}
  285. FUNCTION TempFreeMem: LONGINT;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $3F3C, $0018, $A88F;
  288.     {$ENDC}
  289. {  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
  290. PROCEDURE TempHLock(h: Handle; VAR resultCode: OSErr);
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $3F3C, $001E, $A88F;
  293.     {$ENDC}
  294. PROCEDURE TempHUnlock(h: Handle; VAR resultCode: OSErr);
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $3F3C, $001F, $A88F;
  297.     {$ENDC}
  298. PROCEDURE TempDisposeHandle(h: Handle; VAR resultCode: OSErr);
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $3F3C, $0020, $A88F;
  301.     {$ENDC}
  302. FUNCTION TempTopMem: Ptr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $3F3C, $0016, $A88F;
  305.     {$ENDC}
  306. PROCEDURE InitApplZone;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $A02C;
  309.     {$ENDC}
  310. PROCEDURE InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: INTEGER; limitPtr: UNIV Ptr; startPtr: UNIV Ptr);
  311. PROCEDURE SetZone(hz: THz);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $205F, $A01B;
  314.     {$ENDC}
  315. FUNCTION CompactMem(cbNeeded: Size): Size;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $201F, $A04C, $2E80;
  318.     {$ENDC}
  319. FUNCTION CompactMemSys(cbNeeded: Size): Size;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $201F, $A44C, $2E80;
  322.     {$ENDC}
  323. PROCEDURE PurgeMem(cbNeeded: Size);
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $201F, $A04D;
  326.     {$ENDC}
  327. PROCEDURE PurgeMemSys(cbNeeded: Size);
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $201F, $A44D;
  330.     {$ENDC}
  331. FUNCTION FreeMem: LONGINT;
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $A01C, $2E80;
  334.     {$ENDC}
  335. FUNCTION FreeMemSys: LONGINT;
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $A41C, $2E80;
  338.     {$ENDC}
  339. PROCEDURE ReserveMem(cbNeeded: Size);
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $201F, $A040;
  342.     {$ENDC}
  343. PROCEDURE ReserveMemSys(cbNeeded: Size);
  344.     {$IFC NOT GENERATINGCFM}
  345.     INLINE $201F, $A440;
  346.     {$ENDC}
  347. FUNCTION MaxMem(VAR grow: Size): Size;
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $225F, $A11D, $2288, $2E80;
  350.     {$ENDC}
  351. FUNCTION MaxMemSys(VAR grow: Size): Size;
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $225F, $A51D, $2288, $2E80;
  354.     {$ENDC}
  355. PROCEDURE SetGrowZone(growZone: GrowZoneUPP);
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $205F, $A04B;
  358.     {$ENDC}
  359. PROCEDURE SetApplLimit(zoneLimit: UNIV Ptr);
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $205F, $A02D;
  362.     {$ENDC}
  363. PROCEDURE MoveHHi(h: Handle);
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $205F, $A064;
  366.     {$ENDC}
  367. PROCEDURE DisposePtr(p: Ptr);
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $205F, $A01F;
  370.     {$ENDC}
  371. FUNCTION GetPtrSize(p: Ptr): Size;
  372. PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $201F, $205F, $A020;
  375.     {$ENDC}
  376. PROCEDURE DisposeHandle(h: Handle);
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $205F, $A023;
  379.     {$ENDC}
  380. PROCEDURE SetHandleSize(h: Handle; newSize: Size);
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $201F, $205F, $A024;
  383.     {$ENDC}
  384. FUNCTION GetHandleSize(h: Handle): Size;
  385. FUNCTION InlineGetHandleSize(h: Handle): Size;
  386.     {$IFC NOT GENERATINGCFM}
  387.     INLINE $205F, $A025, $2E80;
  388.     {$ENDC}
  389. PROCEDURE ReallocateHandle(h: Handle; byteCount: Size);
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $201F, $205F, $A027;
  392.     {$ENDC}
  393. PROCEDURE EmptyHandle(h: Handle);
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $205F, $A02B;
  396.     {$ENDC}
  397. PROCEDURE HSetRBit(h: Handle);
  398.     {$IFC NOT GENERATINGCFM}
  399.     INLINE $205F, $A067;
  400.     {$ENDC}
  401. PROCEDURE HClrRBit(h: Handle);
  402.     {$IFC NOT GENERATINGCFM}
  403.     INLINE $205F, $A068;
  404.     {$ENDC}
  405. PROCEDURE MoreMasters;
  406.     {$IFC NOT GENERATINGCFM}
  407.     INLINE $A036;
  408.     {$ENDC}
  409. PROCEDURE BlockMove(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  410.     {$IFC NOT GENERATINGCFM}
  411.     INLINE $201F, $225F, $205F, $A02E;
  412.     {$ENDC}
  413. PROCEDURE BlockMoveData(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  414.     {$IFC NOT GENERATINGCFM}
  415.     INLINE $201F, $225F, $205F, $A22E;
  416.     {$ENDC}
  417. PROCEDURE PurgeSpace(VAR total: LONGINT; VAR contig: LONGINT);
  418. FUNCTION HGetState(h: Handle): SInt8;
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $205F, $A069, $1E80;
  421.     {$ENDC}
  422. PROCEDURE HSetState(h: Handle; flags: ByteParameter);
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $101F, $205F, $A06A;
  425.     {$ENDC}
  426. PROCEDURE SetApplBase(startPtr: UNIV Ptr);
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $205F, $A057;
  429.     {$ENDC}
  430. PROCEDURE MaxApplZone;
  431.     {$IFC NOT GENERATINGCFM}
  432.     INLINE $A063;
  433.     {$ENDC}
  434. FUNCTION HoldMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  435.     {$IFC NOT GENERATINGCFM}
  436.     INLINE $225F, $205F, $7000, $A05C, $3E80;
  437.     {$ENDC}
  438. FUNCTION UnholdMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  439.     {$IFC NOT GENERATINGCFM}
  440.     INLINE $225F, $205F, $7001, $A05C, $3E80;
  441.     {$ENDC}
  442. FUNCTION LockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  443.     {$IFC NOT GENERATINGCFM}
  444.     INLINE $225F, $205F, $7002, $A05C, $3E80;
  445.     {$ENDC}
  446. FUNCTION LockMemoryContiguous(address: UNIV Ptr; count: LONGINT): OSErr;
  447.     {$IFC NOT GENERATINGCFM}
  448.     INLINE $225F, $205F, $7004, $A05C, $3E80;
  449.     {$ENDC}
  450. FUNCTION UnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  451.     {$IFC NOT GENERATINGCFM}
  452.     INLINE $225F, $205F, $7003, $A05C, $3E80;
  453.     {$ENDC}
  454. FUNCTION GetPhysical(VAR addresses: LogicalToPhysicalTable; VAR physicalEntryCount: LONGINT): OSErr;
  455. FUNCTION DeferUserFn(userFunction: UserFnUPP; argument: UNIV Ptr): OSErr;
  456.     {$IFC NOT GENERATINGCFM}
  457.     INLINE $201F, $205F, $A08F, $3E80;
  458.     {$ENDC}
  459. FUNCTION DebuggerGetMax: LONGINT;
  460.     {$IFC NOT GENERATINGCFM}
  461.     INLINE $7000, $A08D, $2E80;
  462.     {$ENDC}
  463. PROCEDURE DebuggerEnter;
  464.     {$IFC NOT GENERATINGCFM}
  465.     INLINE $7001, $A08D;
  466.     {$ENDC}
  467. PROCEDURE DebuggerExit;
  468.     {$IFC NOT GENERATINGCFM}
  469.     INLINE $7002, $A08D;
  470.     {$ENDC}
  471. PROCEDURE DebuggerPoll;
  472.     {$IFC NOT GENERATINGCFM}
  473.     INLINE $7003, $A08D;
  474.     {$ENDC}
  475. FUNCTION GetPageState(address: UNIV Ptr): PageState;
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $205F, $7004, $A08D, $3E80;
  478.     {$ENDC}
  479. FUNCTION PageFaultFatal: BOOLEAN;
  480.     {$IFC NOT GENERATINGCFM}
  481.     INLINE $7005, $A08D, $1E80;
  482.     {$ENDC}
  483. FUNCTION DebuggerLockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  484.     {$IFC NOT GENERATINGCFM}
  485.     INLINE $225F, $205F, $7006, $A08D, $3E80;
  486.     {$ENDC}
  487. FUNCTION DebuggerUnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  488.     {$IFC NOT GENERATINGCFM}
  489.     INLINE $225F, $205F, $7007, $A08D, $3E80;
  490.     {$ENDC}
  491. FUNCTION EnterSupervisorMode: StatusRegisterContents;
  492.     {$IFC NOT GENERATINGCFM}
  493.     INLINE $7008, $A08D, $3E80;
  494.     {$ENDC}
  495. { StripAddress and Translate24To32 macro to nothing on PowerPC
  496.    StripAddress is implemented as a trap in System 6 or later }
  497. {$IFC SystemSixOrLater }
  498. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  499.     {$IFC NOT GENERATINGCFM}
  500.     INLINE $201F, $A055, $2E80;
  501.     {$ENDC}
  502. {$ELSEC}
  503. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  504. {$ENDC}
  505. FUNCTION Translate24To32(addr24: UNIV Ptr): Ptr;
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $201F, $A091, $2E80;
  508.     {$ENDC}
  509. FUNCTION HandToHand(VAR theHndl: Handle): OSErr;
  510. FUNCTION PtrToXHand(srcPtr: UNIV Ptr; dstHndl: Handle; size: LONGINT): OSErr;
  511.     {$IFC NOT GENERATINGCFM}
  512.     INLINE $201F, $225F, $205F, $A9E2, $3E80;
  513.     {$ENDC}
  514. FUNCTION PtrToHand(srcPtr: UNIV Ptr; VAR dstHndl: Handle; size: LONGINT): OSErr;
  515. FUNCTION HandAndHand(hand1: Handle; hand2: Handle): OSErr;
  516.     {$IFC NOT GENERATINGCFM}
  517.     INLINE $225F, $205F, $A9E4, $3E80;
  518.     {$ENDC}
  519. FUNCTION PtrAndHand(ptr1: UNIV Ptr; hand2: Handle; size: LONGINT): OSErr;
  520.     {$IFC NOT GENERATINGCFM}
  521.     INLINE $201F, $225F, $205F, $A9EF, $3E80;
  522.     {$ENDC}
  523. {$IFC OLDROUTINENAMES }
  524. FUNCTION ApplicZone: THz;
  525.     {$IFC NOT GENERATINGCFM}
  526.     INLINE $2EB8, $02AA;
  527.     {$ENDC}
  528. FUNCTION MFTempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  529.     {$IFC NOT GENERATINGCFM}
  530.     INLINE $3F3C, $001D, $A88F;
  531.     {$ENDC}
  532. FUNCTION MFMaxMem(VAR grow: Size): Size;
  533.     {$IFC NOT GENERATINGCFM}
  534.     INLINE $3F3C, $0015, $A88F;
  535.     {$ENDC}
  536. FUNCTION MFFreeMem: LONGINT;
  537.     {$IFC NOT GENERATINGCFM}
  538.     INLINE $3F3C, $0018, $A88F;
  539.     {$ENDC}
  540. PROCEDURE MFTempHLock(h: Handle; VAR resultCode: OSErr);
  541.     {$IFC NOT GENERATINGCFM}
  542.     INLINE $3F3C, $001E, $A88F;
  543.     {$ENDC}
  544. PROCEDURE MFTempHUnlock(h: Handle; VAR resultCode: OSErr);
  545.     {$IFC NOT GENERATINGCFM}
  546.     INLINE $3F3C, $001F, $A88F;
  547.     {$ENDC}
  548. PROCEDURE MFTempDisposHandle(h: Handle; VAR resultCode: OSErr);
  549.     {$IFC NOT GENERATINGCFM}
  550.     INLINE $3F3C, $0020, $A88F;
  551.     {$ENDC}
  552. FUNCTION MFTopMem: Ptr;
  553.     {$IFC NOT GENERATINGCFM}
  554.     INLINE $3F3C, $0016, $A88F;
  555.     {$ENDC}
  556. PROCEDURE ResrvMem(cbNeeded: Size);
  557.     {$IFC NOT GENERATINGCFM}
  558.     INLINE $201F, $A040;
  559.     {$ENDC}
  560. PROCEDURE DisposPtr(p: Ptr);
  561.     {$IFC NOT GENERATINGCFM}
  562.     INLINE $205F, $A01F;
  563.     {$ENDC}
  564. PROCEDURE DisposHandle(h: Handle);
  565.     {$IFC NOT GENERATINGCFM}
  566.     INLINE $205F, $A023;
  567.     {$ENDC}
  568. PROCEDURE ReallocHandle(h: Handle; byteCount: Size);
  569.     {$IFC NOT GENERATINGCFM}
  570.     INLINE $201F, $205F, $A027;
  571.     {$ENDC}
  572. {$ENDC}
  573.  
  574. {$ALIGN RESET}
  575. {$POP}
  576.  
  577. {$SETC UsingIncludes := MemoryIncludes}
  578.  
  579. {$ENDC} {__MEMORY__}
  580.  
  581. {$IFC NOT UsingIncludes}
  582.  END.
  583. {$ENDC}
  584.